Method and apparatus for converting between a multi-bit TDM bus and a single-bit TDM bus using digital logic

ABSTRACT

A system and method for converting data between a multi-bit time division multiplexed (TDM) bus and a faster single-bit TDM bus, wherein each TDM bus communicates data by means of frames, each frame comprising a fixed number of slots and each slot comprising a fixed number of bits, the system comprising digital circuitry for establishing a clock rate RSB for the faster single-bit TDM bus that has the following relationship to a clock rate RMB for the multi-bit TDM bus: RSB=RMB*((slots per frame)*(bits per slot)+1) DIVIDED (slots per frame).

BACKGROUND

1. Technical Field

This invention relates to electronic systems, and more particularly to a method and apparatus for converting between a multi-bit time division multiplexed bus and a single-bit time division multiplexed bus.

2. Background Information

Modern electronic systems frequently make use of a backplane (sometimes called a "motherboard") having connectors for multiple plug-in cards (sometimes called "daughterboards"). In FIG. 1 is a block diagram of a backplane based electronic system. Such a system may be used for a computer architecture, a communications processing system, and a wide variety of other electronic systems.

As shown in FIG. 1, a backplane 10 is coupled by a low speed time-division multiplexed (TDM) multiple bit (i.e., parallel or Multi-Bit TDM) bus 12 to several low speed cards 14 and to a high speed card 16. The Multi-Bit TDM bus 12, the backplane 10, and the low speed cards 14 typically operate at a clock rate of about 20 MHz or less (this rate is exemplary only).

The high speed card 16 contains high speed components 18 that may operate, for example, at an internal clock rate in excess of 100 MHz (this rate is exemplary only). Such a rate may be needed, for example, in certain signal processing applications where incoming and outgoing data are inherently serial, such as in digital telephony. A high speed time-division multiplexed single-bit (i.e., serial or Single-Bit TDM) bus 20 is used for internal data communications.

Using a lower speed Multi-Bit TDM bus 12 on the backplane 10 rather then a high speed Single-Bit TDM bus 20 throughout the system allows use of slower, less expensive technology components for the backplane 10 and eliminates a requirement that all cards coupled to the backplane 10 be high speed. Consequently, signals passing between the Multi-Bit TDM bus 12 and the Single-Bit TDM bus 20 must be format converted (serial/parallel) and synchronized by means of a converter interface 22. Conventional designs use a phase lock loop to synchronize the high speed Single-Bit TDM bus 20 with the slower speed Multi-Bit TDM Bus 12.

The inventor has determined that it would be desirable to use a purely digital technique to perform such synchronization. The present invention provides such a technique.

SUMMARY

The invention is a system and method for converting data between a multi-bit time division multiplexed (TDM) bus and a faster single-bit TDM bus, wherein each TDM bus communicates data by means of frames, each frame comprising a fixed number of slots and each slot comprising a fixed number of bits, the system comprising digital circuitry for establishing a clock rate R_(SB) for the faster single-bit TDM bus that has the following relationship to a clock rate R_(MB) for the multi-bit TDM bus: R_(SB) =R_(MB) *((slots per frame)*(bits per slot)+1)÷(slots per frame).

Since data moves from the faster single-bit TDM bus to the slower multi-bit TDM bus, the data must first appear on the faster bus and be translated to the slower bus. In accordance with a preferred embodiment of the invention, a Sync signal on the slower bus is fixed (Slow₋₋ Sync). A Sync signal on the Fast bus (Fast₋₋ Sync) is modified to precede the Slow₋₋ Sync by a selected number of clock cycles. This is done by advancing or delaying the Fast₋₋ Sync pulse by up to one clock cycle every frame if required. In the preferred embodiment, this function is accomplished by counting the number of cycles between the Fast₋₋ Sync pulse and the Slow₋₋ Sync pulse normalized to the clock edge for the slower bus.

Since data moves from the slower Multi-bit TDM bus to the faster Single-bit TDM bus, the data will first appear on the Slow bus and be translated to the Fast bus. In accordance with the invention, the Slow₋₋ Sync signal is fixed. Accordingly, the Fast₋₋ Sync signal can be easily modified to follow the Slow₋₋ Sync signal by a fixed number of clock cycles. This is done without explicitly advancing or delaying the Fast₋₋ Sync signal but by directly converting the Slow₋₋ Sync into the Fast₋₋ Sync.

The details of one or more embodiments of the invention are set forth in the accompanying drawings and the description below. Other features, objects, and advantages of the invention will be apparent from the description and drawings, and from the claims.

DESCRIPTION OF DRAWINGS

FIG. 1 is a block diagram of a prior art backplane based electronic system.

FIG. 2 is a timing diagram showing a 2-slot by 4-bit Single-Bit TDM frame.

FIG. 3 is a timing diagram showing a 2-slot by 4-bit Multi-Bit TDM frame.

FIG. 4 is a timing diagram showing a 2-slot by 4-bit Single-Bit to Multi-Bit TDM conversion in accordance with the present invention.

FIG. 5 is a block diagram of one implementation of a Single-Bit to Multi-Bit TDM bus converter in accordance with the invention.

FIG. 6 is a block diagram of one implementation of a Multi-Bit to Single-Bit TDM bus converter in accordance with the invention.

Like reference numbers and designations in the various drawings indicate like elements.

DETAILED DESCRIPTION

A time division multiplexed (TDM) bus communicates data by means of frames. Each frame of a TDM bus comprises a fixed number of slots, with each slot comprising a fixed number of bits. A "Sync" signal is used to indicate the beginning of a frame.

FIG. 2 is a timing diagram showing a 2-slot by 4-bit single-bit TDM frame. Slot 0 includes the first four bits of data in the first frame, starting after the Sync signal. Slot 1 includes the last four bits of data in the first frame.

FIG. 3 is a timing diagram showing a 2-slot by 4-bit multi-bit TDM frame. Slot 0 includes the first four bits of data in the first frame, starting after the Sync signal. The bits are carried by four data lines, D0-D3. Slot 1 includes the last four bits of data in the first frame.

Conversion of a multi-bit TDM bus to/from a single-bit TDM bus using purely digital means in accordance with the invention can be accomplished by using a clock rate R_(SB) for the faster single-bit TDM bus that has the following relationship to the clock rate R_(MB) of the slower multi-bit TDM bus:

    R.sub.SB =R.sub.MB *((slots per frame)*(its per slot)+1)÷(slots per frame)

Implementation of this relationship has the effect of providing up to one extra clock pulse on the higher speed single-bit TDM bus for every frame. This extra clock pulse provides the flexibility for the single-bit TDM bus to accelerate or delay the Sync signal one clock without dropping data. Synchronization logic digitally locks onto the slower multi-bit TDM bus clock at the beginning of each frame using the Sync signal and free runs for the remainder of each frame. Standard clock oscillators have variances of less than or equal to about 100 parts per million (PPM). Hence, once synchronized, the separate clocks for the single-bit TDM bus and the multi-bit TDM bus will not vary by more than a single clock pulse of the faster single-bit TDM bus during a single frame provided the following holds true:

    (frame duration)<(single-bit TDM clock duration)/(summed variance of both oscillators)

For example, if the clock rate R_(SB) for the faster single-bit TDM bus is 50 Mhz with a variance of 100 PPM and the multi-bit TDM clock has a variance of 50 PPM, then:

    (Frame Duration)<(1/50 MHz)*(1,000,000/(100+50))=1/(50*15)=133 μsec

Fast Bus to Slow Bus Conversion

The following describes the logic for conversion from a 2-slot, 4-bit, single-bit to multi-bit TDM bus. The principles of the invention apply to other slots per frame counts and bits per slot counts.

Since data moves from the faster single-bit TDM bus to the slower multi-bit TDM bus, the data must first appear on the faster bus and be translated to the slower bus. In accordance with the invention, the Sync signal on the slower bus is fixed (Slow₋₋ Sync). Hence, the Sync signal on the Fast bus (Fast₋₋ Sync) is modified to precede the Slow₋₋ Sync by a selected number of clock cycles. This is done by advancing or delaying the Fast₋₋ Sync pulse by up to one clock cycle every frame if required. In the preferred embodiment, this function is accomplished by counting the number of cycles between the Fast₋₋ Sync pulse and the Slow₋₋ Sync pulse normalized to the clock edge for the slower bus. The two busses are synchronized if they are separated by a clock cycle count of 3. The Fast₋₋ Sync pulse is advanced if the clock cycle count is 2 or less, and delayed if the clock cycle count is 4 or more. If the Slow₋₋ Sync pulse is not found by a clock cycle count of 7, then the Fast₋₋ Sync pulse is delayed by one clock cycle. This provides a mechanism for the busses to acquire synchronization during initial startup.

The counts given above are for a 2-slot, 4-bit, single-bit to multi-bit TDM bus converter. Other counts may be used for other bus configurations.

FIG. 4 is a timing diagram showing a 2-slot by 4-bit single-bit to multi-bit TDM bus conversion in accordance with the invention. The Fast₋₋ Sync pulse for the single-bit (S-B) bus precedes the rising-edge-clocked Slow₋₋ Sync pulse of the multi-bit (M-B) bus by between 3 and 4 faster single-bit TDM clock cycles (S-B-CLK), and is synchronized to the slower multi-bit TDM bus. The data (S-B-DATA) for Slot 0 on the faster single-bit TDM bus is all 0's (4 bits long) and is presented on the slower multi-bit TDM bus approximately 5 faster single-bit TDM clock cycles later. The following data for Slot 1 on the faster single-bit TDM bus is all 1's (4 bits long) and is presented on the slower multi-bit TDM bus approximately 5 faster single-bit TDM clock cycles later. The single-bit TDM bus clock cycle that coincides with the Fast₋₋ Sync pulse will not carry data when the two busses are synchronized, but will carry data if the Fast₋₋ Sync pulse is advanced to maintain synchronization with the slower bus.

FIG. 5 is a block diagram of one implementation of a single-bit to multi-bit TDM bus converter in accordance with the invention. Unless otherwise specified, all blocks are clocked with the clock from the faster bus (Fast₋₋ Clock). Serial data from the faster single-bit TDM bus is coupled to an X-bit wide serial to parallel shift register 500, where "X" is the bit width of the slot of the target multi-bit TDM bus. The output of the parallel shift register 500 is coupled to a synchronization latch 502, which in turn is connected to a buffer latch 504. The buffer latch 504 is clocked by the clock signal from the slower bus (Slow₋₋ Clock). The output of the buffer latch 504 are the parallel data bits for a slot on the slower bus.

A fast bus slot/bit counter 506 counts the number of bits per slot on the faster bus, and the number of slots per frame. The output count is used to latch a slot's worth of bits from the shift register 500 into the synchronization latch 502. The output count is also coupled to a Fast₋₋ Sync generator 508 which uses the count to determine when to output a Sync signal for the faster bus (i.e., once per frame). The Fast₋₋ Sync signal is fed back to the fast bus slot/bit counter 506 to provide start-up synchronization.

The clock from the slower bus (Slow₋₋ Clock) is coupled to an edge detector 510, which outputs a signal to a phase resolution circuit 512 when an edge (preferably the falling edge) of the Slow₋₋ Clock is detected. Other inputs to the phase resolution circuit 512 include the Sync signal for the slower bus (Slow₋₋ Sync), and the Fast₋₋ Sync signal. The fast bus slot/bit counter 506 compares the phase of the Slow₋₋ Sync and Fast₋₋ Sync signals upon each edge detection of the Slow₋₋ Clock signal. If the Fast₋₋ Sync signal differs from the Slow₋₋ Sync signal by 4 or more Fast₋₋ Clock cycles, a Delay signal is generated. If the Fast₋₋ Sync signal differs from the Slow₋₋ Sync signal by 2 or fewer Fast₋₋ Clock cycles, an Advance signal is generated. Such determinations are triggered by the output from the edge detector 510. If the Slow₋₋ Sync signal is not found by a clock cycle count of 7, then the Fast₋₋ Sync signal is delayed by one clock cycle; this provides a mechanism for the busses to acquire synchronization during initial startup.

Slow Bus to Fast Bus Conversion

The following describes the logic for conversion from a 2-slot, 4-bit, multi-bit to single-bit TDM bus. Again, the principles of the invention apply to other slots per frame counts and bits per slot counts.

Since data moves from the slower multi-bit TDM bus to the faster single-bit TDM bus, the data will first appear on the Slow bus and be translated to the Fast bus. In accordance with the invention, the Slow₋₋ Sync signal is fixed. Accordingly, the Fast₋₋ Sync signal can be modified easily to follow the Slow₋₋ Sync signal by a fixed number of clock cycles. This is done without explicitly advancing or delaying the Fast₋₋ Sync signal but by directly converting the Slow₋₋ Sync into the Fast₋₋ Sync.

FIG. 6 is a block diagram of one implementation of a multi-bit to single-bit TDM bus converter in accordance with the invention. Unless otherwise specified, all blocks are clocked by the Fast₋₋ Clock signal. The Slow₋₋ Clock signal is coupled to an edge detector 600, which outputs a signal to a Fast₋₋ Sync generator 602 when an edge (preferably the falling edge) of the Slow₋₋ Clock is detected. Another input to the Fast₋₋ Sync generator 602 is the Slow₋₋ Sync signal. The Fast₋₋ Sync generator 602 outputs a Fast₋₋ Sync signal in response to the output of the edge detector 600, and offset from the Slow₋₋ Sync signal by a fixed number of clock cycles. For conversion from a 2-slot, 4-bit, multi-bit to single-bit TDM bus, the offset is one clock cycle.

The Fast₋₋ Sync signal triggers a bit counter 604, which provides a count of the number of bits per slot on the slower bus. The data bits from the slower bus are coupled to an X-bit wide buffer latch 606, which is clocked by the output from the bit counter 604. The inverse Fast₋₋ Sync signal, Fast₋₋ Sync₋₋ L, enables the buffer latch 606. The latched data bits are coupled to a fast data generator 608, which is essentially a parallel to serial shift register.

Programmable Logic Implementation

Following is the program code for one implementation of the invention using a programmable logic device such as Part No. ispLSI1016-110LJ from Lattice Semiconductor Corp. The implementation is of a 4-bit, 2-slot multi-bit/single-bit TDM converter using the concepts discussed above. This design has been compiled and simulated, and was implemented using Boolean logic. The programming language is the ABEL language. The invention may be implemented in other ways, such as in discrete digital logic, an application specific integrated circuit (ASIC), or fast programmed processor.

    __________________________________________________________________________     "This is an example design for the conversion between a 2 slot, 4 data         line, slow speed                                                               "TDM bus and a 2 slot, 4 bits per slot, single bit high speed TDM bus. It      is assumed                                                                     "that the RX and TX portions of the TDM bus use different sync signals         but a common clock.                                                            "It is also assumed that the Slow bus is a backplane bus with a fixed          Sync signal and                                                                "that the Sync signal on the Fast bus is controlled by the conversion          logic.                                                                         module tdm.sub.-- conv                                                         "Inputs from High Speed TDM bus                                                reset    pin;                                                                  fast.sub.-- clock                                                                       pin;                                                                  fast.sub.-- rx.sub.-- data                                                              pin;                                                                  rs =  reset!;                                                                  fc =  fast.sub.-- clock!;                                                      frd                                                                               =  fast.sub.-- rx.sub.-- data!;                                             "Outputs to High Speed TDM bus                                                 fast.sub.-- tx.sub.-- sync                                                            pin istype `reg`;                                                       fast.sub.-- rx.sub.-- sync                                                            pin istype `reg`;                                                       fast.sub.-- tx.sub.-- data                                                            pin istype `reg`;                                                       fts                                                                               =  fast.sub.-- tx.sub.-- sync!;                                             frs                                                                               =  fast.sub.-- rx.sub.-- sync!;                                             ftd                                                                               =  fast.sub.-- tx.sub.-- data!;                                             "Inputs from Low Speed TDM bus                                                 slow.sub.-- clock                                                                       pin;                                                                  slow.sub.-- tx.sub.-- sync                                                              pin;                                                                  slow.sub.-- rx.sub.-- sync                                                              pin;                                                                  slow.sub.-- rx.sub.-- bit0                                                              pin;                                                                  slow.sub.-- rx.sub.-- bit1                                                              pin;                                                                  slow.sub.-- rx.sub.-- bit2                                                              pin;                                                                  slow.sub.-- rx.sub.-- bit3                                                              pin;                                                                  sc =  slow.sub.-- clock!;                                                      sts                                                                               =  slow.sub.-- tx.sub.-- sync!;                                             srs                                                                               =  slow.sub.-- rx.sub.-- sync!;                                             srd                                                                               =  slow.sub.-- rx.sub.-- bit3, slow.sub.-- rx.sub.-- bit2, slow.sub.--         rx.sub.-- bit1, slow.sub.-- rx.sub.-- bit0!;                                "Outputs to Low Speed TDM bus                                                  slow.sub.-- tx.sub.-- bit0 pin istype `reg`;                                   slow.sub.-- tx.sub.-- bit1 pin istype `reg`;                                   slow.sub.-- tx.sub.-- bit2 pin istype `reg`;                                   slow.sub.-- tx.sub.-- bit3 pin istype `reg`;                                   std =  slow.sub.-- tx.sub.-- bit3, slow.sub.-- tx.sub.-- bit2,                 slow.sub.-- tx.sub.-- bit1, slow.sub.-- tx.sub.-- bit0!;                       "Logic common to both Fast RX to Slow TX and Slow TX to Fast RX                slow.sub.-- clock.sub.-- 10                                                               node istype `reg`;                                                  slow.sub.-- clock.sub.-- 11                                                               node istype `reg`;                                                  slow.sub.-- clock.sub.-- edge                                                             node istype `reg`;                                                  sce =  slow.sub.-- clock.sub.-- edge!;                                         "Logic required for Fast RX to Slow TX TDM conversion                          fast.sub.-- rx.sub.-- sync.sub.-- cnt0                                                     node istype `reg`;                                                 fast.sub.-- rx.sub.-- sync.sub.-- cnt1                                                     node istype `reg`;                                                 fast.sub.-- rx.sub.-- sync.sub.-- cnt2                                                     node istype `reg`;                                                 fast.sub.-- rx.sub.-- sync.sub.-- count                                                    node istype `reg`;                                                 fast.sub.-- rx.sub.-- sync.sub.-- delay                                                    node istype `reg`;                                                 fast.sub.-- rx.sub.-- sync.sub.-- advnc                                                    node istype `reg`;                                                 fast.sub.-- rx.sub.-- data.sub.-- 10                                                       node istype `reg`;                                                 fast.sub.-- rx.sub.-- data.sub.-- 11                                                       node istype `reg`;                                                 fast.sub.-- rx.sub.-- data.sub.-- 12                                                       node istype `reg`;                                                 fast.sub.-- rx.sub.-- data.sub.-- 13                                                       node istype `reg`;                                                 fast.sub.-- rx.sub.-- bit0.sub.-- 1                                                        node istype `reg`;                                                 fast.sub.-- rx.sub.-- bit1.sub.-- 1                                                        node istype `reg`;                                                 fast.sub.-- rx.sub.-- bit2.sub.-- 1                                                        node istype `reg`;                                                 fast.sub.-- rx.sub.-- bit3.sub.-- 1                                                        node istype `reg`;                                                 fast.sub.-- rx.sub.-- bit.sub.-- cnt0                                                      node istype `reg`;                                                 fast.sub.-- rx.sub.-- bit.sub.-- cnt1                                                      node istype `reg`;                                                 fast.sub.-- rx.sub.-- slot.sub.-- cnt0                                                     node istype `reg`;                                                 frscn                                                                             =  fast.sub.-- rx.sub.-- sync.sub.-- cnt2, fast.sub.-- rx.sub.--               sync.sub.-- cnt1, fast.sub.-- rx.sub.-- sync.sub.-- cnt0!;                  frsc                                                                              =  fast.sub.-- rx.sub.-- sync.sub.-- count!;                                frsd                                                                              =  fast.sub.-- rx.sub.-- sync.sub.-- de1ay!;                                frsa                                                                              =  fast.sub.-- rx.sub.-- sync.sub.-- advnc!;                                frd0                                                                              =  fast.sub.-- rx.sub.-- data.sub.-- 10!;                                   frd1                                                                              =  fast.sub.-- rx.sub.-- data.sub.-- 11!;                                   frd2                                                                              =  fast.sub.-- rx.sub.-- data.sub.-- 12!;                                   frd3                                                                              =  fast.sub.-- rx.sub.-- data.sub.-- 13!;                                   frb                                                                               =  fast.sub.-- rx.sub.-- bit3.sub.-- 1, fast.sub.-- rx.sub.-- bit2.sub.        -- 1, fast.sub.-- rx.sub.-- bit1.sub.-- 1, fast.sub.-- rx.sub.--               bit0.sub.-- 1!;                                                             frbc                                                                              =  fast.sub.-- rx.sub.-- bit.sub.-- cnt1, fast.sub.-- rx.sub.--                bit.sub.-- cnt0!;                                                           fr1c                                                                              =  fast.sub.-- rx.sub.-- slot.sub.-- cnt0!;                                 "Logic required for Slow RX to Fast TX TDM conversion                          slow.sub.-- rx.sub.-- sync.sub.-- 1                                                        node istype `reg`;                                                 fast.sub.-- tx.sub.-- bit.sub.-- cnt0                                                      node istype `reg`;                                                 fast.sub.-- tx.sub.-- bit.sub.-- cnt1                                                      node istype `reg`;                                                 fast.sub.-- tx.sub.-- sync.sub.-- 1                                                        node istype `reg`;                                                 slow.sub.-- rx.sub.-- bit0.sub.-- 1                                                        node istype `reg`;                                                 slow.sub.-- rx.sub.-- bit1.sub.-- 1                                                        node istype `reg`;                                                 slow.sub.-- rx.sub.-- bit2.sub.-- 1                                                        node istype `reg`;                                                 slow.sub.-- rx.sub.-- bit3.sub.-- 1                                                        node istype `reg`;                                                 srs1                                                                              =  slow.sub.-- rx.sub.-- sync.sub.-- 1!;                                    ftbc                                                                              =  fast.sub.-- tx.sub.-- bit.sub.-- cnt1, fast.sub.-- tx.sub.--                bit.sub.-- cnt0!;                                                           fts1                                                                              =  fast.sub.-- tx.sub.-- sync.sub.-- 1!;                                    srb1                                                                              =  slow.sub.-- rx.sub.-- bit3.sub.-- 1, slow.sub.-- rx.sub.-- bit2.sub.        -- 1, slow.sub.-- rx.sub.-- bit1.sub.-- 1, slow.sub.-- rx.sub.--               bit0.sub.-- 1!;                                                             x  = .X.;                                                                      equations                                                                      "*************************************************************************     **                                                                             "The following provides the logic used for both the Fast RX to Slow TX         "and Slow RX to Fast TX TDM busses                                             "*************************************************************************     **                                                                             "synchronize to the slow clock edges                                           slow.sub.-- clock.sub.-- 10                                                                := slow.sub.-- clock & |reset;                                     slow.sub.-- clock.sub.-- 10.clk                                                            = |fast.sub.-- clock;                                              slow.sub.-- clock.sub.-- 11                                                                := slow.sub.-- clock.sub.-- 10 & |reset;                           slow.sub.-- clock.sub.-- 11.clk                                                            = |fast clock;                                                     "Synchronizing to the falling edge plus 1/2 slot time                          "(2 clocks) which is the rising edge of the clock.                             slow.sub.-- clock.sub.-- edge                                                              := |slow.sub.-- clock.sub.-- 10 & slow.sub.-- clock.sub.-- 11                  & |reset;                                                          slow.sub.-- clock.sub.-- edge.clk                                                          = |fast.sub.-- clock;                                              "*********************************************************************         "The following provides the logic for the conversion from a 2-slot,            "4 bit, single-bit to multi-bit TDM bus.                                       "Since the data moves from the Single-bit Fast bus to the Multi-bit            "Slow bus, the data must first appear on the Fast bus and be translated        "to the Slow bus. Since the Sync on the Slow bus is fixed, the Sync on         the                                                                            "Fast bus must be modified to precede that of the Slow bus by the proper       "number of clock cycles. This is done by advancing or delaying the Fast        Sync                                                                           "pulse one clock cycle every frame if required. This is accomplished by        "counting the number of cycles between the Fast Sync pulse and the Slow        Sync                                                                           "pulse normalized to the Slow clock edge. The busses are synchronized if       "they are separated by a count of 3. Fast Sync is advanced if the count        is                                                                             "2 or less, and delayed if count is 4 or more. If the Slow Sync pulse is       "not found by a count of 7, then the Fast pulse is delayed by one. This        "provides a mechanism for the busses to acquire synchronization during         "initial startup.                                                              "*************************************************************************     **                                                                             "Count clocks from Fast Sync to Slow Sync, resets to 0 on |fast.sub.--         rx.sub.-- sync.sub.-- count                                                    fast.sub.-- rx.sub.-- sync.sub.-- cnt0 := fast.sub.-- rx.sub.-- sync.sub.-     - count                                                                        & |fast.sub.-- rx.sub.-- sync.sub.-- cnt0 & |reset;                            fast.sub.-- rx.sub.-- sync.sub.-- cnt0.clk = |fast.sub.-- clock;               fast.sub.-- rx.sub.-- sync.sub.-- cnt1 := fast.sub.-- rx.sub.-- sync.sub.-     - count                                                                        & |fast.sub.-- rx.sub.-- sync.sub.-- cnt0 & fast.sub.-- rx.sub.--              sync.sub.-- cnt1 & |reset                                                      # fast.sub.-- rx.sub.-- sync.sub.-- count                                      & fast.sub.-- rx.sub.-- sync.sub.-- cnt0 & |fast.sub.-- rx.sub.--              sync.sub.-- cnt1 & |reset;                                                     fast.sub.-- rx.sub.-- sync.sub.-- cnt1.clk = |fast.sub.-- clock;               fast.sub.-- rx.sub.-- sync.sub.-- cnt2 := fast.sub.-- rx.sub.-- sync.sub.-     - count                                                                        & fast.sub.-- rx.sub.-- sync.sub.-- cnt0 & fast.sub.-- rx.sub.-- sync.sub.     -- cnt1 & |fast.sub.-- rx.sub.-- sync.sub.-- cnt2 & |reset                     # fast.sub.-- rx.sub.-- sync.sub.-- count                                      & |fast.sub.-- rx.sub.-- sync.sub.-- cnt0 & fast.sub.-- rx.sub.--              sync.sub.-- cnt2 & |reset                                                      # fast.sub.-- rx.sub.-- sync.sub.-- count                                      & |fast.sub.-- rx.sub.-- sync.sub.-- cnt1 & fast.sub.-- rx.sub.--              sync.sub.-- cnt2 & |reset;                                                     fast.sub.-- rx.sub.-- sync.sub.-- cnt2.clk = |fast.sub.-- clock;               "Count from Fast Sync to Slow Sync clock edge or if sync counter goes to       7                                                                              fast.sub.-- rx.sub.-- sync.sub.-- count := fast.sub.-- rx.sub.-- sync &        |reset                                                                         # |slow.sub.-- clock.sub.-- edge & |fast.sub.-- rx.sub.-- sync.sub.--          cnt0 & fast.sub.-- rx.sub.-- sync.sub.-- count & |reset                        # |slow.sub.-- clock.sub.-- edge & |fast.sub.-- rx.sub.-- sync.sub.--          cnt1 & fast.sub.-- rx.sub.-- sync.sub.-- count & |reset                        # |slow.sub.-- clock.sub.-- edge & |fast.sub.-- rx.sub.-- sync.sub.--          cnt2 & fast.sub.-- rx.sub.-- sync.sub.-- count & |reset                        # |slow.sub.-- tx.sub.-- sync & |fast.sub.-- rx.sub.-- sync.sub.-- cnt0 &      fast.sub.-- rx.sub.-- sync.sub.-- count & |reset                               # |slow.sub.-- tx.sub.-- sync & |fast.sub.-- rx.sub.-- sync.sub.-- cnt1 &      fast.sub.-- rx.sub.-- sync.sub.-- count & |reset                               # |slow.sub.-- tx.sub.-- sync & |fast.sub.-- rx.sub.-- sync.sub.-- cnt2 &      fast.sub.-- rx.sub.-- sync.sub.-- count & |reset;                              fast.sub.-- rx.sub.-- sync.sub.-- count.clk = |fast.sub.-- clock;              "Advance next Fast Sync if 2 or less Fast clock between Syncs and stay         active                                                                         "Until Slot cnt = 1 and bit cnt = 2                                            fast.sub.-- rx.sub.-- sync.sub.-- advnc := fast.sub.-- rx.sub.-- sync.sub.     -- count & slow.sub.-- clock.sub.-- edge & slow.sub.-- tx.sub.-- sync          & |fast.sub.-- rx.sub.-- sync.sub.-- cnt0 & |fast.sub.-- rx.sub.--             sync.sub.-- cnt2 & |reset                                                      # fast.sub.-- rx.sub.-- sync.sub.-- count & slow.sub.-- clock.sub.-- edge      & slow.sub.-- tx.sub.-- sync                                                   & |fast.sub.-- rx.sub.-- sync.sub.-- cnt1 & |fast.sub.-- rx.sub.--             sync.sub.-- cnt2 & |reset                                                      # fast.sub.-- rx.sub.-- sync.sub.-- advnc & |fast.sub.-- rx.sub.--             slot.sub.-- cnt0 & |reset                                                      # fast.sub.-- rx.sub.-- sync.sub.-- advnc & |fast.sub.-- rx.sub.--             bit.sub.-- cnt1 & |reset                                                       # fast.sub.-- rx.sub.-- sync.sub.-- advnc & fast.sub.-- rx.sub.--              bit.sub.-- cnt0 & |reset;                                                      fast.sub.-- rx.sub.-- sync.sub.-- advnc.clk = |fast.sub.-- clock;              "Delay next Fast Sync if 4 or more Fast clocks between Syncs and stay          active                                                                         "Until Slot cnt = 0 and bit cnt = 0                                            fast.sub.-- rx.sub.-- sync.sub.-- delay := fast.sub.-- rx.sub.-- sync.sub.     -- count & slow.sub.-- clock.sub.-- edge & slow.sub.-- tx.sub.-- sync          & fast.sub.-- rx.sub.-- sync.sub.-- cnt2 & |reset                              # fast.sub.-- rx.sub.-- sync.sub.-- delay & fast.sub.-- rx.sub.--              slot.sub.-- cnt0 & |reset                                                      # fast.sub.-- rx.sub.-- sync.sub.-- delay & fast.sub.-- rx.sub.--              bit.sub.-- cnt1 & |reset                                                       # fast.sub.-- rx.sub.-- sync.sub.-- delay & fast.sub.-- rx.sub.--              bit.sub.-- cnt0 & |reset;                                                      fast.sub.-- rx.sub.-- sync.sub.-- delay.clk = |fast.sub.-- clock;              "Count Bits per slot, resets to 0 on fast.sub.-- rx.sub.-- sync                fast.sub.-- rx.sub.-- bit.sub.-- cnt0 := |fast.sub.-- rx.sub.-- sync &         |fast.sub.-- rx.sub.-- bit.sub.-- cnt0 & |reset;                               fast.sub.-- rx.sub.-- bit.sub.-- cnt0.clk = |fast clock;                       fast.sub.-- rx.sub.-- bit.sub.-- cnt1 := |fast.sub.-- rx.sub.-- sync &         fast.sub.-- rx.sub.-- bit cnt0 & |fast rx bit cnt1 & |reset                    # |fast.sub.-- rx.sub.-- sync & |fast.sub.-- rx.sub.-- bit.sub.-- cnt0 &       fast.sub.-- rx.sub.-- bit.sub.-- cnt1 & |reset;                                fast.sub.-- rx.sub.-- bit.sub.-- cnt1.clk = |fast.sub.-- clock;                "Count Slots, resets to 0 on fast.sub.-- rx.sub.-- sync                        fast.sub.-- rx.sub.-- slot.sub.-- cnt0 := |fast.sub.-- rx.sub.-- sync &        |fast.sub.-- rx.sub.-- slot.sub.-- cnt0                                        & fast.sub.-- rx.sub.-- bit.sub.-- cnt0 & fast.sub.-- rx.sub.-- bit.sub.--      cnt1 & |reset                                                                 # |fast.sub.-- rx.sub.-- sync & fast.sub.-- rx.sub.-- slot.sub.-- cnt0 &       |fast.sub.-- rx.sub.-- bit.sub.-- cnt0 & |reset                                # |fast.sub.-- rx.sub.-- sync & fast.sub.-- rx.sub.-- slot.sub.-- cnt0 &       |fast.sub.-- rx.sub.-- bit.sub.-- cnt1 & |reset;                               fast.sub.-- rx.sub.-- slot.sub.-- cnt0.clk = |fast clock;                      "Generate Fast Sync signal                                                     "if in sync then generate on                                                                 Slot = 1, Bits = 3                                               "if delay set then generate on                                                               Slot = 0, Bits = 0                                               "if advance set then generate on                                                             Slot = 1, Bits = 2                                               fast.sub.-- rx.sub.-- sync := |fast.sub.-- rx.sub.-- sync.sub.-- delay &       |fast.sub.-- rx.sub.-- sync.sub.-- advnc & |fast.sub.-- rx.sub.-- sync         & fast.sub.-- rx.sub.-- slot.sub.-- cnt0 & fast.sub.-- rx.sub.-- bit.sub.-     - cnt1 & fast.sub.-- rx.sub.-- bit.sub.-- cnt0 & |reset                        # fast.sub.-- rx.sub.-- sync.sub.-- delay & |fast.sub.-- rx.sub.-- sync        & |fast.sub.-- rx.sub.-- slot.sub.-- cnt0 & |fast.sub.-- rx.sub.--             bit.sub.-- cnt1 & |fast.sub.-- rx.sub.-- bit.sub.-- cnt0 & |reset              # fast.sub.-- rx.sub.-- sync.sub.-- advnc & |fast.sub.-- rx.sub.-- sync        & fast.sub.-- rx.sub.-- slot.sub.-- cnt0 & fast.sub.-- rx.sub.-- bit.sub.-     - cnt1 & |fast.sub.-- rx bit cnt0 & |reset;                                    fast.sub.-- rx.sub.-- sync.clk = |fast.sub.-- clock;                           "Latch Fast data through bit shifter                                           fast.sub.-- rx.sub.-- data 10                                                              := fast.sub.-- rx.sub.-- data & |reset;                            fast.sub.-- rx.sub.-- data.sub.-- 10.clk                                                   = fast.sub.-- clock;                                               fast.sub.-- rx.sub.-- data.sub.-- 11                                                       := fast.sub.-- rx.sub.-- data.sub.-- 10 & |reset;                  fast.sub.-- rx.sub.-- data.sub.-- 11.clk                                                   = fast.sub.-- clock;                                               fast.sub.-- rx.sub.-- data.sub.-- 12                                                       := fast.sub.-- rx.sub.-- data.sub.-- 11 & |reset;                  fast.sub.-- rx.sub.-- data.sub.-- 12.clk                                                   = fast.sub.-- clock;                                               fast.sub.-- rx.sub.-- data.sub.-- 13                                                       := fast.sub.-- rx.sub.-- data.sub.-- 12 & |reset;                  fast.sub.-- rx.sub.-- data.sub.-- 13.clk                                                   = fast.sub.-- clock;                                               "Latch Fast data from bit shifter to temporary holding register on the         bit                                                                            "count of 3                                                                    fast.sub.-- rx.sub.-- bit0.sub.-- 1 := fast.sub.-- rx.sub.-- bit.sub.--        cnt1 & fast.sub.-- rx.sub.-- bit.sub.-- cnt0 & fast.sub.-- rx.sub.-- data      10 & |reset                                                                    # |fast.sub.-- rx.sub.-- bit.sub.-- cnt1 & fast.sub.-- rx.sub.-- bit0.sub.     -- 1 & |reset                                                                  # |fast.sub.-- rx.sub.-- bit.sub.-- cnt0 & fast.sub.-- rx.sub.-- bit0.sub.     -- 1 & |reset;                                                                 fast.sub.-- rx.sub.-- bit0.sub.-- 1.clk = |fast clock;                         fast.sub.-- rx.sub.-- bit1.sub.-- 1 := fast.sub.-- rx.sub.-- bit.sub.--        cnt1 & fast.sub.-- rx.sub.-- bit.sub.-- cnt0 & fast.sub.-- rx.sub.--           data.sub.-- 11 & |reset                                                        # |fast.sub.-- rx.sub.-- bit.sub.-- cnt1 & fast.sub.-- rx.sub.-- bit1.sub.     -- 1 & |reset                                                                  # |fast.sub.-- rx.sub.-- bit.sub.-- cnt0 & fast.sub.-- rx.sub.-- bit1.sub.     -- 1 & |reset;                                                                 fast.sub.-- rx.sub.-- bitl.sub.-- 1.clk = |fast.sub.-- clock;                  fast.sub.-- rx.sub.-- bit2.sub.-- 1 := fast.sub.-- rx.sub.-- bit cnt1 &        fast rx bit.sub.-- cnt0 & fast.sub.-- rx.sub.-- data 12 & |reset               # |fast.sub.-- rx.sub.-- bit.sub.-- cnt1 & fast.sub.-- rx.sub.-- bit2.sub.     -- 1 & |reset                                                                  # |fast.sub.-- rx.sub.-- bit.sub.-- cnt0 & fast.sub.-- rx.sub.-- bit2.sub.     -- 1 & |reset;                                                                 fast.sub.-- rx.sub.-- bit2.sub.-- 1.clk = |fast.sub.-- clock;                  fast.sub.-- rx.sub.-- bit3.sub.-- 1 := fast.sub.-- rx.sub.-- bit.sub.--        cnt1 & fast rx bit.sub.-- cnt0 & fast.sub.-- rx.sub.-- data 13 & |reset        # |fast.sub.-- rx.sub.-- bit.sub.-- cnt1 & fast.sub.-- rx.sub.-- bit3.sub.     -- 1 & |reset                                                                  # |fast.sub.-- rx.sub.-- bit.sub.-- cnt0 & fast.sub.-- rx.sub.-- bit3.sub.     -- 1 & |reset;                                                                 fast.sub.-- rx.sub.-- bit3.sub.-- 1.clk = |fast.sub.-- clock;                  "Latch Fast Data from temporary register to Slow bus                           slow.sub.-- tx.sub.-- bit0                                                                 := fast.sub.-- rx.sub.-- bit0.sub.-- 1 & |reset;                   slow.sub.-- tx.sub.-- bit0.clk                                                             = |slow.sub.-- clock;                                              slow.sub.-- tx.sub.-- bit1                                                                 := fast.sub.-- rx.sub.-- bit1.sub.-- 1 & |reset;                   slow.sub.-- tx.sub.-- bit1.clk                                                             = |slow.sub.-- clock;                                              slow.sub.-- tx.sub.-- bit2                                                                 := fast.sub.-- rx.sub.-- bit2.sub.-- 1 & |reset;                   slow.sub.-- tx.sub.-- bit2.clk                                                             = |slow.sub.-- clock;                                              slow.sub.-- tx.sub.-- bit3                                                                 := fast.sub.-- rx.sub.-- bit3.sub.-- 1 & |reset;                   slow.sub.-- tx.sub.-- bit3.clk                                                             = |slow.sub.-- clock;                                              "*********************************************************************         "The following provides the logic for the conversion from a 2-slot,            "4 bit, multi-bit to single-bit TDM bus.                                       "                                                                              "Since the data moves from the Multi-bit Slow bus to the Single-bit            "Fast bus, the data will first appear on the Slow bus and be translated        "to the Fast bus. Since the Sync on the Slow bus is fixed, the Sync on         the                                                                            "Fast bus can be easily modified to follow that of the Slow bus by a           fixed                                                                          "number of clock cycles. This is done without explicitly advancing or          "delaying the Fast Sync signal but by directly converting the Slow Sync        "into the Fast Sync.                                                           "*************************************************************************     **                                                                             "Latch the Slow RX data Bits in the middle of the bit cell which starts        as                                                                             "slow clock.sub.-- edge & slow.sub.-- rx.sub.-- sync delayed one clock         for the first slot time                                                        "and samples at bit count = 3 for the rest of the frame                        slow.sub.-- rx bit0.sub.-- 1 := fast.sub.-- tx.sub.-- sync.sub.-- 1 &          slow.sub.-- rx bit0 & |reset                                                   # fast.sub.-- tx.sub.-- bit.sub.-- cnt1 & fast.sub.-- tx.sub.-- bit.sub.--      cnt0 & slow rx bit0 & |reset                                                  # |fast.sub.-- tx.sub.-- sync.sub.-- 1 & |fast.sub.-- tx.sub.-- bit.sub.--      cnt0 & slow.sub.-- rx.sub.-- bit0 & |reset                                    # |fast.sub.-- tx.sub.-- sync.sub.-- 1 & |fast.sub.-- tx.sub.-- bit.sub.--      cnt1 & slow.sub.-- rx.sub.-- bit0 & |reset;                                   slow.sub.-- rx.sub.-- bit0.sub.-- 1.clk = |fast.sub.-- clock;                  slow.sub.-- rx bit1.sub.-- 1 := fast.sub.-- tx.sub.-- sync.sub.-- 1 &          slow.sub.-- rx bit1 & |reset                                                   # fast.sub.-- tx.sub.-- bit.sub.-- cnt1 & fast.sub.-- tx.sub.-- bit.sub.--      cnt0 & slow.sub.-- rx.sub.-- bit1 & |reset                                    # |fast.sub.-- tx.sub.-- sync.sub.-- 1 & |fast.sub.-- tx.sub.-- bit.sub.--      cnt0 & slow.sub.-- rx.sub.-- bit1.sub.-- 1 & |reset                           # |fast.sub.-- tx.sub.-- sync.sub.-- 1 & |fast.sub.-- tx.sub.-- bit.sub.--      cnt1 & slow.sub.-- rx.sub.-- bit1.sub.-- 1 & |reset;                          slow.sub.-- rx.sub.-- bit1.sub.-- 1.clk = |fast.sub.-- clock;                  slow.sub.-- rx.sub.-- bit2.sub.-- 1 := fast.sub.-- tx.sub.-- sync.sub.--       1 & slow.sub.-- rx.sub.-- bit2 & |reset                                        # fast.sub.-- tx.sub.-- bit.sub.-- cnt1 & fast.sub.-- tx.sub.-- bit.sub.--      cnt0 & slow.sub.-- rx.sub.-- bit2 & |reset                                    # |fast.sub.-- tx.sub.-- sync.sub.-- 1 & |fast.sub.-- tx.sub.-- bit.sub.--      cnt0 & slow.sub.-- rx.sub.-- bit2.sub.-- 1 & |reset                           # |fast.sub.-- tx.sub.-- sync.sub.-- 1 & |fast.sub.-- tx.sub.-- bit.sub.--      cnt1 & slow.sub.-- rx.sub.-- bit2.sub.-- 1 & |reset;                          slow.sub.-- rx.sub.-- bit2.sub.-- 1.clk = |fast.sub.-- clock;                  slow.sub.-- rx.sub.-- bit3.sub.-- 1 := fast.sub.-- tx.sub.-- sync.sub.--       1 & slow.sub.-- rx bit3 & |reset                                               # fast.sub.-- tx.sub.-- bit.sub.-- cnt1 & fast.sub.-- tx.sub.-- bit.sub.--      cnt0 & slow.sub.-- rx.sub.-- bit3 & |reset                                    # |fast.sub.-- tx.sub.-- sync.sub.-- 1 & |fast.sub.-- tx.sub.-- bit.sub.--      cnt0 & slow.sub.-- rx.sub.-- bit3.sub.-- 1 & |reset                           # |fast.sub.-- tx.sub.-- sync.sub.-- 1 & |fast.sub.-- tx.sub.-- bit.sub.--      cnt1 & slow.sub.-- rx.sub.-- bit3.sub.-- 1 & |reset;                          slow.sub.-- rx.sub.-- bit3.sub.-- 1.clk = |fast.sub.-- clock;                  "Latch the Slow Sync signal                                                    slow.sub.-- rx.sub.-- sync.sub.-- 1 := slow.sub.-- clock.sub.-- edge &         slow.sub.-- rx.sub.-- sync & |reset                                            # |slow.sub.-- clock.sub.-- edge & slow.sub.-- rx.sub.-- sync.sub.-- 1 &       |reset;                                                                        slow.sub.-- rx.sub.-- sync.sub.-- 1.clk = |fast.sub.-- clock;                  "Keep a counter for which bit is being sent on the Fast TDM bus,               "resets on fast.sub.-- tx.sub.-- sync.sub.-- 1                                 fast.sub.-- tx.sub.-- bit.sub.-- cnt0 := |fast.sub.-- tx.sub.-- sync.sub.-     - 1 & |fast.sub.-- tx.sub.-- bit.sub.-- cnt0 & |reset;                         fast.sub.-- tx.sub.-- bit.sub.-- cnt0.clk = |fast.sub.-- clock;                fast.sub.-- tx.sub.-- bit.sub.-- cnt1 := |fast.sub.-- tx.sub.-- sync.sub.-     - 1 & fast.sub.-- tx.sub.-- bit.sub.-- cnt0 & |fast.sub.-- tx.sub.--           bit.sub.-- cnt1 & |reset                                                       # |fast.sub.-- tx.sub.-- sync.sub.-- 1 & |fast.sub.-- tx.sub.-- bit.sub.--      cnt0 & fast.sub.-- tx.sub.-- bit.sub.-- cnt1 & |reset;                        fast.sub.-- tx.sub.-- bit.sub.-- cnt1.clk = |fast.sub.-- clock;                "Generate the Fast Sync Signal & delay it by one relative to slow.sub.--       clock.sub.-- edge                                                              fast.sub.-- tx.sub.-- sync.sub.-- 1 := slow.sub.-- clock.sub.-- edge &         slow.sub.-- rx.sub.-- sync.sub.-- 1 & |reset;                                  fast.sub.-- tx.sub.-- sync.sub.-- 1.clk = |fast.sub.-- clock;                  fast.sub.-- tx.sub.-- sync := fast.sub.-- tx.sub.-- sync.sub.-- 1 &            |reset;                                                                        fast.sub.-- tx.sub.-- sync.clk = |fast.sub.-- clock;                           "Generate the Fast TDM Data                                                    fast.sub.-- tx.sub.-- data := |fast tx bit cnt0 & |fast.sub.-- tx.sub.--       bit.sub.-- cnt0 & slow.sub.-- rx.sub.-- bit3.sub.-- 1 & |reset                 # fast.sub.-- tx.sub.-- bit.sub.-- cnt0 & |fast.sub.-- tx.sub.-- bit.sub.-     - cnt0 & slow.sub.-- rx.sub.-- bit2.sub.-- 1 & |reset                          # |fast.sub.-- tx.sub.-- bit.sub.-- cnt0 & fast.sub.-- tx.sub.-- bit.sub.-     - cnt0 & slow.sub.-- rx.sub.-- bit1.sub.-- 1 & |reset                          # fast.sub.-- tx.sub.-- bit.sub.-- cnt0 & fast.sub.-- tx.sub.-- bit cnt0       & slow.sub.-- rx.sub.-- bit0.sub.-- 1 & |reset;                                fast.sub.-- tx.sub.-- data.clk = |fast.sub.-- clock;                           end                                                                            __________________________________________________________________________

A number of embodiments of the present invention have been described. Nevertheless, it will be understood that various modifications may be made without departing from the spirit and scope of the invention. For example, since the multi-bit bus can have any number of data lines from 1 to n, the invention will also work in synchronizing two single bit busses. Accordingly, other embodiments are within the scope of the following claims. 

What is claimed is:
 1. A system for converting data between a multi-bit time division multiplexed bus and a faster single-bit time division multiplexed bus, wherein each time division multiplexed bus communicates data by means of frames, each frame comprising a fixed number of slots and each slot comprising a fixed number of bits, the system including digital circuitry for establishing a clock rate R_(SB) for the faster single-bit time division multiplexed bus that has the following relationship to a clock rate R_(MB) for the multi-bit time division multiplexed bus:

    R.sub.SB =R.sub.MB *((slots per frame)*(bits per slot)+1)÷(slots per frame).


2. A system for converting data from a single-bit time division multiplexed bus to a slower multi-bit time division multiplexed bus, wherein each bus communicates data by means of frames, each frame comprising a fixed number of slots and each slot comprising a fixed number of bits, each bus having a Sync signal indicating the beginning of each frame and a clock signal, the system comprising:(a) a phase resolution circuit, coupled to the Sync signal of each bus and to the clock signal of the multi-bit bus, for determining a phase relationship between the Sync signal of the single-bit bus and the Sync signal of the multi-bit bus relative to the clock signal of the multi-bit bus, and outputting a phase signal indicative of such determination; (b) a synchronization generator, coupled to the output of the phase resolution circuit, for generating an advanced or delayed Sync signal for the single-bit bus in response to the phase signal; and (c) single-bit to multi-bit conversion and buffering circuitry, coupled to the data from the single-bit bus, the advanced or delayed Sync signal for the single-bit bus, and the clock signal of the multi-bit bus, for converting data from the single-bit bus to the multi-bit bus in synchronization with the clock signal of the multi-bit bus and the advanced or delayed Sync signal for the single-bit bus.
 3. The system claim of 2, wherein the phase signal output of the phase resolution circuit is indicative of the number of cycles between the Sync signal for the single-bit bus and the Sync signal for the multi-bit bus.
 4. The system claim of 2, wherein the rate of the clock signal, R_(SB), for the single-bit bus has the following relationship to the rate of the clock signal, R_(MB) for the multi-bit bus:

    R.sub.SB =R.sub.MB *((slots per frame)*(bits per slot)+1)÷(slots per frame).


5. A system for converting data from a multi-bit time division multiplexed bus to a faster single-bit time division multiplexed bus, wherein each bus communicates data by means of frames, each frame comprising a fixed number of slots and each slot comprising a fixed number of bits, each bus having a Sync signal indicating the beginning of each frame and a clock signal, the system comprising:(a) an edge detector circuit for detecting a triggering edge of the clock signal of the multi-bit bus; (b) a synchronization generator, coupled to the output of the edge detector circuit and to the Sync signal of the multi-bit bus, for generating a delayed Sync signal for the single-bit bus in response to the output signal of the edge detector circuit and in delayed synchronization with the Sync signal of the multi-bit bus; and (c) multi-bit to single-bit conversion and buffering circuitry, coupled to the data from the multi-bit bus and the delayed Sync signal for the single-bit bus, for converting data from the multi-bit bus to the single-bit bus in synchronization with the delayed Sync signal for the single-bit bus.
 6. A method for converting data between a multi-bit time division multiplexed bus and a faster single-bit time division multiplexed bus, wherein each time division multiplexed bus communicates data by means of frames, each frame comprising a fixed number of slots and each slot comprising a fixed number of bits, including the step of establishing a clock rate R_(SB) for the faster single-bit time division multiplexed bus that has the following relationship to a clock rate R_(MB) for the multi-bit time division multiplexed bus:

    R.sub.SB =R.sub.MB *((slots per frame)*(bits per slot)+1)÷(slots per frame).


7. A method for converting data from a single-bit time division multiplexed bus to a slower multi-bit time division multiplexed bus, wherein each bus communicates data by means of frames, each frame comprising a fixed number of slots and each slot comprising a fixed number of bits, each bus having a Sync signal indicating the beginning of each frame and a clock signal, the method comprising the steps of:(a) determining a phase relationship between the Sync signal of the single-bit bus and the Sync signal of the multi-bit bus relative to the clock signal of the multi-bit bus, and outputting a phase signal indicative of such determination; (b) generating an advanced or delayed Sync signal for the single-bit bus in response to the phase signal; and (c) converting data from the single-bit bus to the multi-bit bus in synchronization with the clock signal of the multi-bit bus and the advanced or delayed Sync signal for the single-bit bus.
 8. The method claim of 7, wherein the phase signal is indicative of the number of cycles between the Sync signal for the single-bit bus and the Sync signal for the multi-bit bus.
 9. The method claim of 7, wherein the rate of the clock signal, R_(SB), for the single-bit bus has the following relationship to the rate of the clock signal, R_(MB), for the multi-bit bus:

    R.sub.SB =R.sub.MB *((slots per frame)*(bits per slot)+1)÷(slots per frame).


10. 10. A method for converting data from a multi-bit time division multiplexed bus to a faster single-bit time division multiplexed bus, wherein each bus communicates data by means of frames, each frame comprising a fixed number of slots and each slot comprising a fixed number of bits, each bus having a Sync signal indicating the beginning of each frame and a clock signal, the method comprising the steps of:(a) detecting a triggering edge of the clock signal of the multi-bit bus; (b) generating a delayed Sync signal for the single-bit bus in response to the detected triggering edge and in delayed synchronization with the Sync signal of the multi-bit bus; and (c) converting data from the multi-bit bus to the single-bit bus in synchronization with the delayed Sync signal for the single-bit bus. 